\documentclass{article}

\usepackage[top=2.5cm, bottom=2.5cm, left=2cm, right=2cm]{geometry}
\usepackage{fancyhdr}
\lhead{\bsc{Programmation Orientee Objet}}
\rhead{\bsc{TD7}}
\renewcommand{\headrulewidth}{1px}
\lfoot{ \bsc{Enseirb-Matmeca}}
\rfoot{ \bsc{Informatique - I2}}
\renewcommand{\footrulewidth}{1px}
\pagestyle{fancy}
\usepackage{wrapfig}
\usepackage{multicol}
\usepackage{textcomp}
\usepackage[T1]{fontenc}
\usepackage{setspace}
\usepackage{graphicx} 

%\usepackage[vlined,lined,boxed,french,longend]{algorithm2e}

\usepackage{graphicx}
\usepackage[french]{babel}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{mathrsfs}
\usepackage{xcolor}
\usepackage[utf8]{inputenc}
%%%%%%%%%%%%%%%% Variables %%%%%%%%%%%%%%%%
\def\projet{2}
\def\titre{Lot 3: Modification de la réalisation \\
  --------------------- \\ Gestion d'erreurs du paquetage tec}
\def\groupe{2}
\def\equipe{piyovimoad}
\def\responsible{vpomier}
\def\tandemi{ppocquetduhautjusse, avilliermet}
\def\tandemii{ydubernet, mmegzari}

\begin{document}
%%%%%%%%%%%%%%%% Header %%%%%%%%%%%%%%%%
\noindent\begin{minipage}{\textwidth}
\vskip 0mm
\noindent
    { \begin{tabular}{p{7.5cm}}
        {\bfseries \sffamily
          Rapport du TD n°7 de l'équipe \equipe}
        \begin{center}{\itshape \titre}\end{center}
    \end{tabular}}
    \hfill 
    \fbox{\begin{tabular}{l}
        {~\hfill \bfseries \sffamily 23/10/12 \hspace{1.5mm} \hfill~} \\[2mm] 
        Coordinateur : \responsible \\
        Tandem1 : \tandemi \\
        Tandem2 : \tandemii
    \end{tabular}}
    \vskip 4mm ~

    \parbox{\textwidth}{\small \textit{Travail restant à la fin de la séance~:}

A la fin de la séance il restait encore les parties 2 et 3 à finir. On a passé un peu de temps au début de la séance à bien comprendre le mécanisme d'exceptions d'où peut être un retard dans l'avancement. 


}
 \vskip 2mm ~

%\parbox{\textwidth}{\small \textit{Remarques~:}}


 %   \vskip 1mm ~
\end{minipage}




%%%%%%%%%%%%%%%% Main part %%%%%%%%%%%%%%%%
\section{Gestion d'erreur et instanciation}

On retourne ici dans la classe \texttt{JaugeNaturel}. On étudie deux cas d'instanciation:

\vskip 2mm ~

\begin{itemize}

\item \texttt{vigieMax} a une valeur inférieure à \texttt{vigieMin}. 

\item \texttt{vigieMax},\texttt{vigieMin}, \texttt{depart} sont égaux.

\end{itemize}

\vskip 2mm ~

Dans les 2 cas on a une incohérence, en effet la jauge se retrouve alors dans 2 états différents (2 couleurs) au même moment. Il faut donc gérer ce genre d'erreur (instanciation avec des paramètres invalides), on utilisera pour cela le mécanisme des exceptions. Il s'agira d’indiquer l'erreur et de remettre l'objet dans un état cohérent. L’instanciation doit échouer.

\vskip 2mm ~

Dans notre code on lève alors l’exception \texttt{IllegalArgumentException} dans le constructeur de la classe \texttt{JaugeNaturel}. Dans cette exécution on remarque qu'une seule exception est levée et non pas les deux. En fait les exceptions ne sont pas capturées, elles sont seulement propagées, donc le compilateur provoque une erreure.

\vskip 2mm ~

Pour vérifier que les exceptions sont bien levées, nous allons utiliser un test dans lequel l'exception sera capturée. Si l’exception est bien capturée, le test ne doit rien afficher (comportement voulu). Sinon on utilise l’instruction suivante \texttt{assert false: message;} pour renvoyer une erreure.

On vérifie donc que les deux exceptions sont levées en vérifiant que le test est passé. Pour ce qui est des valeurs, dans le \texttt{catch}, \texttt{inverse} et \texttt{egale} sont des jauges naturelles qui ont pour valeur \texttt{ROUGE} et \texttt{BLEU} en même temps. Enfin, pour pouvoir utiliser les variables dans la clause \texttt{try} et \texttt{catch} il faut les déclarer avant le bloc \texttt{try} et on les instancie dans le bloc \texttt{try}.

On rappelle que dans les mécanismes d'exceptions le bloc \texttt{try} permet d'exécuter des instructions susceptibles de lever une exception et que le bloc \texttt{catch} permet d'exécuter des instructions en lien avec l'exception levée.

\vskip 2mm ~

On vérifie bien que notre test échoue si l’exception n’est pas levée.


\section{Paquetage tec}

On va étudier ici les exceptions controlées. L’objectif de ces exceptions est d'éviter de laisser des erreurs se propager à l’exécution. Une fois une exception levée, des instructions sont exécutées pour corriger les erreurs et continuer l'exécution sans problème. L'utilisation des exceptions controlées uniquement à l'exérieur du framework permet aux développeurs de modifier leur système de gestion d'erreurs plus facilement, ils peuvent ne pas modifier le prototype des méthodes internes au packetage.

\vskip 2mm ~
Dans le paquetage \texttt{tec} on définit la classe \texttt{TecInvalidException} qui définit 2 constructeurs avec mécanisme de surcharge:

\vskip 2mm ~

\begin{itemize}

\item \texttt{IllegalStateException(illegalSTATEexception)} 

\item \texttt{IllegalArgumentException(illegalargumentexception)}

\end{itemize}

\vskip 2mm ~



La classe \texttt{TecInvalidException} ne doit pas hériter de \texttt{IllegalStateException} car c'est une exception non controlée. Pour spécifier la propagation de l'exception \texttt{TecInvalidException}, on ajoute le mot clef \texttt{throws} dans les prototypes des méthodes \texttt{monterDans()} et \texttt{allerArretSuivant()}. Pour instancier les exceptions on procède de la manière suivante:

\begin{verbatim}
 public TecInvalidException(IllegalStateException e){
      super(e.getMessage(), e);
  }
    
 public TecInvalidException(IllegalArgumentException e){
      super(e.getMessage(),e);
  }

\end{verbatim}


\section{Boutez vos neurones}

\subsection{"Java Collection Framework"}

Dans cette partie, l'objectif est d'implémenter une nouvelle représentation des passagers d'un bus à l'aide des classes conteneurs. Le framework est défini à partir de deux catégories de type «abstrait» : la structure de données (ou conteneurs) et le parcours de la structure de données (ou itérateur) avec l’interface \texttt{Iterator}. Voici quelques précisions sur les interfaces liées aux conteneurs: 


\vskip 2mm ~
\begin{itemize}


\item{L'interface \texttt{Collection} est l'interface de base dans la hiérarchie des collections. Elle représente un groupe d'objets identifié comme ses élements et définie des méthodes pour les manipuler. Cette interface est surtout créée pour servir de base des implémentations d'usage, elle n'est implementée directement que pour des situations très générales.}

\item{L'interface \texttt{List} hérite de l'interface collection de façon à représenter une liste ordonnée (séquence). L'utilisateur de cette interface a un contrôle total de la place où insérer un élément, y accéder avec son index entier et chercher un élément dans la liste.}

\item{L'interface \texttt{Set} hérite de l'interface collection pour représenter la définition mathématique d'un ensemble. Cette représentation ne peut contenir des élements dupliqués ou plusieurs éléments \texttt{null}.}

\item{L'interface \texttt{Map} est une interface de base qui représente un objet permettant de faire correspondre des clés entières à des valeurs. La duplication des clés n'est pas permise.}


\end{itemize}
\vskip 2mm ~

On sépare le parcours de la structure de données afin d'éviter de définir un parcours pour chaque type de collection, et ainsi eviter une grande duplication du code.

Ce framework utilise le mecanisme de type-parametré car comme les conteneurs sont des collections d'objets quelconques, cela permet d'imposer une cohérence entre les différents éléments d'une même collection et aussi écrire du code générique.

\subsection{Remaniement de la classe Autobus}

\vskip 4mm ~

La réalisation de la classe Autobus utilise un conteneur de type List. Le parcours du conteneur se faisant grâce à un itérateur.

Dans le code de la classe \texttt{ArrayList}, on regarde de quelle manière est effectuée la suppression d’un élément:
 
\vskip 4mm ~

\begin{verbatim}

public E remove(int index)

{
       rangeCheck(index);
       modCount++;
       E oldValue = elementData(index);
        int numMoved = size - index - 1;
       if (numMoved  > 0)
           System.arraycopy(elementData, index+1, elementData, index,
                            numMoved);
       elementData[--size] = null; // Let gc do its work
       return oldValue;
}


\end{verbatim}
\vskip 2mm ~

A partir du code, on en déduit que l'ancienne liste est copiée à un nouvel emplacement sans la valeur supprimée.

\vskip 2mm ~

De la même manière dans le code de la classe \texttt{LinkedList}:



\begin{verbatim}

public boolean remove(Object o)

{
       if (o == null) {
           for (Node< E > x = first; x != null; x = x.next) {
               if (x.item == null) {
                   unlink(x);
                   return true;
               }
           }
       } else {
           for (Node< E > x = first; x != null; x = x.next) {
               if (o.equals(x.item)) {
                   unlink(x);
                   return true;
               }
           }
       }
       return false;
}


\end{verbatim}

\vskip 2mm ~

Avec \texttt{unlink(x)} on détruit le lien vers l'élément x, on supprime donc l'élément de cette manière.

\section{Conclusion}

En conclusion ce TD nous a permis d'étudier plus en détails le mécanisme des exceptions. Après un démarrage difficile la  première partie a été réalisée sans problèmes majeurs. Cependant la deuxième partie et la dernière partie ``Boutez vos neurones'' ont posé plus de problèmes de compréhension, il nous a malheureusment manqué du temps pour les finir complètement.

\end{document}
